package com.yt.system.controller;

import com.github.pagehelper.Page;
import com.yt.system.dao.ClockMapper;
import com.yt.system.domain.*;
import com.yt.system.service.ClockService;
import com.yt.system.service.UserService;
import com.yt.system.service.VacateService;
import com.yt.system.utils.PageHelperUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 高铭
 * @date 2019/9/18 - 16:00
 *  管理员对分组操作的相关接口详列
 */
@Api(value = "分组相关操作的接口",tags = "管理员分组、考勤操作")
@RestController
public class AdminController {
    @Autowired
    private UserService userService;

    @Autowired
    ClockService clockService;

    @Autowired
    VacateService vacateService;

    /**
     * 管理员对所有人重置组别
     * @return
     */
    @ApiOperation(value = "管理员对所有人重置组别")
    @RequestMapping(value = "/adminFindAllUser",method = RequestMethod.POST)
    public Map<String,Object> resrtAllTheGroup(){
        //随机分组时候，将上周的分组信息表状态设置为1(代表过去的)
        userService.updateGroupMessageStatus();
        //将用户角色表全部清理
        userService.deleteUserRole();
        //将usertemplate 用户临时表也删除
        userService.delUserTemplate();
        /*List<User> userList = userService.adminFindAllUser();
        int totalPeople = userList.size();
        map.put("userList",userList);*/
        Map<String,Object> map = new HashMap<>();
        map.put("msg","成功重置分组");
        return map;
    }

    /**
     * 传入组别的gid,对这个组进行重置组别
     * @param gid
     * @return
     */
    @ApiOperation(value = "传入组别的gid,对这个组进行重置组别")
    @RequestMapping(value = "resetTheGroup",method = RequestMethod.GET)
    public String resetTheGroup(Integer gid){
        //先修改这组的状态
        userService.resetTheGroup(gid);
        //将user_role用户-角色表中的对应数据删除，避免了下周组长出现数据冲突
        userService.deleteUserRoleByGid(gid);
        //将重置组别的所有人员信息添加到usertemplate
        userService.saveAllPeopleToUserTemplate(gid);
        //修改这组人员的  组别--人员 状态,代表将这组人员的信息状态改变为过去
        userService.resetTheGroupPeopleMsg(gid);
        return "对某个组进行重置组别成功";
    }

    /**
     * 传入用户的uid以及所在组别的gid,对某个人进行组别重置（将这个人从组别中移除出去）
     * @param uid
     * @param gid
     * @return
     */
    @ApiOperation(value = "传入用户的uid以及所在组别的gid,对某个人进行组别重置（将这个人从组别中移除出去）")
    @RequestMapping(value = "resetTheGroupOnePeople",method = RequestMethod.GET)
    public String resetTheGroupOnePeople(Integer uid,Integer gid){
        //判断这个用户是否是这个组的组长，如果这个人认识组长，则将用户-角色表（user_role）的组长信息删除
        UserRole userRole = userService.userIsLeader(uid,gid);
        if(userRole != null){
            //如果它不为空，则说明是组长，就要把这个组长信息删除
            userService.deleteGroupLeader(gid);
        }
        //将这个用户从当前这个组软删除 ---- 更改group_message 中的status变为 1，成为历史
        int result = userService.resetTheGroupOnePeople(uid,gid);
        //然后将这个用户存进用户临时表usertemplate中
        userService.saveUserToUserTemplate(uid);
        return "成功的将这个人从组别中移除出去";
    }

    /**
     * 管理员对全部人员的随机分组
     * @param groupTotalNum 小组数量
     * @param eachGroupPeople   每个小组的人数
     * @return
     */
    @ApiOperation(value = "管理员输入groupTotalNum(指定组别数量)，或者指定eachGroupPeople（每组人数）进行全员随机分组")
    @RequestMapping(value = "/adminRandomToAllGroup",method = RequestMethod.POST)
    public Map<String,Object> adminRandomToAllGroup(Integer groupTotalNum ,Integer eachGroupPeople){
        Map<String,Object> map = new HashMap<>();
        //将用户-角色表的数据全部删除（保留管理员以及超级管理员的数据），避免选出组长出现数据重复（与上周冲突）
        userService.deleteUserRole();
        //得到用户的信息
        List<User> userList = userService.adminFindAllUser();
        //得到总数量
        Integer totalPeople = userList.size();
        //当分组的总数量比总人数还要大，就提示输入的组别数量有错
        if(totalPeople < groupTotalNum){
           map.put("code",0);
           map.put("msg","不好意思，你输入的要分组总数量大于总人数，不符合，输入有误");
            return map;
        }else{
            map = userService.adminRandomToAllGroup(groupTotalNum,eachGroupPeople,userList);
            //得到随机分组的总数量组别
            List<Integer> allTheGid = userService.getAllTheGid();
            Integer totalGroupGid = allTheGid.size();
            userService.insertGroupAccount(totalGroupGid);
            return map;
        }
    }

    /**
     * 管理员特定分组
     * @return
     */
    @ApiOperation(value = "管理员特定分组（还没完善）")
    @RequestMapping(value = "/adminSpecialSplitGroup",method = RequestMethod.POST)
    public Map<String,Object> adminSpecialSplitGroup() {

        return null;
    }
    /*
     * 管理员插入考勤信息
     * @param clock
     * @return
     */
    @ApiOperation(value = "管理员插入考勤信息")
    @PostMapping("/insertClock")
    public Map<String,Object> insertClock(Clock clock) {
        Map<String, Object> map = new HashMap<>();
        int a = clockService.insertClock(clock);
        if (a > 0){
            map.put("code", 1);
            map.put("msg", "插入成功！");
            return map;
        }
        map.put("code", 0);
        map.put("msg", "插入失败！");
        return map;
    }

    /**
     * 管理员删除考勤信息
     * @param cid
     * @return
     */
    @ApiOperation(value = "管理员删除考勤信息")
    @PostMapping("/deleteClock")
    public Map<String,Object> deleteClock(Integer cid) {
        Map<String, Object> map = new HashMap<>();
        int a = clockService.deleteClock(cid);
        if (a > 0){
            map.put("code", 1);
            map.put("msg", "删除成功！");
            return map;
        }
        map.put("code", 0);
        map.put("msg", "删除失败！");
        return map;
    }

    /**
     * 管理员更新考勤信息
     * @param clock
     * @return
     */
    @ApiOperation(value = "管理员更新考勤信息")
    @PostMapping("/updateClock")
    public Map<String,Object> updateClock(Clock clock) {
        Map<String, Object> map = new HashMap<>();
        int a = clockService.updateClock(clock);
        if (a > 0){
            map.put("code", 1);
            map.put("msg", "更新成功！");
            return map;
        }
        map.put("code", 0);
        map.put("msg", "更新失败！");
        return map;
    }

    /**
     * 根据entertime或leavetime或cstatus或cflag查询考勤信息
     * @param clock
     * @return
     */
    @ApiOperation(value = "根据entertime或leavetime或cstatus或cflag查询考勤信息")
    @PostMapping("/findAllByClock")
    public PageVO<Object> findAllByClock(Clock clock, PageQO pageQO){
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        clockService.findAllByClock(clock);
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    /**
     * 根据用户名name查询考勤信息
     * @param name
     * @return
     */
    @ApiOperation(value = "根据用户名name查询考勤信息")
    @PostMapping("/findAllClockOrName")
    public PageVO<Object> findAllClockOrName(String name, PageQO pageQO){
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        clockService.findAllClockOrName(name);
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    @ApiOperation(value = "根据vstatus、vflag查询请假记录")
    @PostMapping("/findAllByVacate")
    public PageVO<Object> findAllByVacate(Vacate vacate, PageQO pageQO){
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        vacateService.findAllByVacate(vacate);
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    @ApiOperation(value = "根据用户名name查询请假记录")
    @PostMapping("/findAllByName")
    public PageVO<Object> findAllByName(String name, PageQO pageQO){
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        vacateService.findAllByName(name);
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    @ApiOperation(value = "管理员插入请假记录")
    @PostMapping("/insertVacate")
    public Map<String,Object> insertVacate(Vacate vacate) {
        Map<String, Object> map = new HashMap<>();
        int a = vacateService.insertVacate(vacate);
        if (a > 0){
            map.put("code", 1);
            map.put("msg", "插入成功！");
            return map;
        }
        map.put("code", 0);
        map.put("msg", "插入失败！");
        return map;
    }

    @ApiOperation(value = "管理员更新请假记录")
    @PostMapping("/updateVacate")
    public Map<String,Object> updateVacate(Vacate vacate) {
        Map<String, Object> map = new HashMap<>();
        int a = vacateService.updateVacate(vacate);
        if (a > 0){
            map.put("code", 1);
            map.put("msg", "更新成功！");
            return map;
        }
        map.put("code", 0);
        map.put("msg", "更新失败！");
        return map;
    }

    @ApiOperation(value = "管理员删除请假记录")
    @PostMapping("/deleteVacate")
    public Map<String,Object> deleteVacate(Integer vid) {
        Map<String, Object> map = new HashMap<>();
        int a = vacateService.deleteVacate(vid);
        if (a > 0){
            map.put("code", 1);
            map.put("msg", "删除成功！");
            return map;
        }
        map.put("code", 0);
        map.put("msg", "删除失败！");
        return map;
    }

    /**
     * 查出当周每组组员的信息
     * @return
     */
    @ApiOperation(value = "查出当周每组组员的信息，以分好组的形式返回," +
            "组别的成员信息以UserAndRoleMsg+id形式返回，其中用户中的roid = 2 ,说明是组长")
    @RequestMapping(value = "getGroupPeopleMsg",method = RequestMethod.POST)
     public Map<String,Object> getGroupPeopleMsg(){
        //得到这周的组别
        List<Integer> gidList = userService.getAllTheGid();
       Map<String,Object> map = userService.getGroupAndPeopleMsg(gidList);
        return map;
    }

    /**
     *  选出组长并确认组长
     * @param uid
     * @param gid
     * @return
     */
    @ApiOperation(value = "选出组长并确认组长(当这个组已经有组长了，就不能为这个组添加组长了)")
    @RequestMapping(value = "sureGroupLeader",method = RequestMethod.POST)
    public Map<String,Object> sureGroupLeader(Integer uid,Integer gid){
        Map<String,Object> map = new HashMap<>();
        //先判断这个组是否有了组长
        UserRole userRole = userService.groupIsHaveLeader(gid);
        if(userRole != null){
            //如果它不为空，则说明是组长，就要把这个组长信息删除
            map.put("code",1);
            map.put("msg","不好意思，这个组已经有组长了");
            return map;
        }else{
            userService.sureGroupLeader(uid,gid);
            map.put("code",0);
            map.put("msg","成功选出组长并确认组长");
            return map;
        }
    }

    /**
     * 传入用户所在组的组别id,拿到用户所在组别信息以及组员信息
     * @param gid
     * @return
     */
    @ApiOperation(value = "传入用户所在组的组别id,拿到用户所在组别信息以及组员信息")
    @RequestMapping(value = "getGroupAndPeopleMsg",method = RequestMethod.POST)
    public Map<String,Object> getTheGroupTeamMsg(Integer gid){
        Map<String,Object> map = new HashMap<>();
        //拿用户组别的信息
        GroupTable groupTable = userService.getGroupTable(gid);
        //拿用户组别的组员信息
        List<User> groupTableList = userService.getGroupTableList(gid);
        map.put("groupTable",groupTable);
        map.put("groupTableList",groupTableList);
        return map;
    }

    @ApiOperation(value = "查找重置分组之后处于没安排组别状态的所有人员")
    @RequestMapping( value = "findAllNoInGroupPeople",method = RequestMethod.GET)
    public List<User> findAllNoInGroupPeople(){
        List<User> userList = userService.findAllNoInGroupPeople();
        return userList;
    }
    @ApiOperation(value = "将某个重置分组之后处于没安排组别状态的人员拉进具体的组别里")
    @RequestMapping( value = "pullPeopleToGroup",method = RequestMethod.GET)
    public String pullPeopleToGroup(Integer uid,Integer gid){
        //将某个重置分组之后处于没安排组别状态的人员拉进具体的组别里
        userService.pullPeopleToGroup(uid,gid);
        return "成功的将某个游离人员拉近组别";
    }
    @ApiOperation(value = "查询当周所有有效的组别（方便将游离人员添加到指定组别中）")
    @RequestMapping( value = "getAllRealGid",method = RequestMethod.GET)
    public List<Integer> getAllRealGid(){
        List<Integer> allTheGid = userService.getAllTheGid();
        return allTheGid;
    }
}
